package projet.volleystat.bdd;

import java.util.ArrayList;
import java.util.TreeMap;

import projet.volleystat.DatabaseException;
import projet.volleystat.Player;
import projet.volleystat.Team;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

/**
 * @author Lameira Nelaupe Ferrand Fiore
 * @version 1.0
 * 
 *          Manipulation de la base de donnees et des tables avec differentes
 *          methodes.
 */
public class VolleyRepository implements IRepository {
	// SLDB pouur SQL Lite Data Base
	protected SQLiteDatabase SLDataBase;
	protected SQLiteOpenHelper SLOHhelper;

	/**
	 * @param context
	 *            Instanciation de la base de donnees.
	 */
	public VolleyRepository(Context context) {
		SLOHhelper = new VolleyOpenhelper(context, null);
	}

	/**
	 * Ouverture de la base de donnees
	 */
	public void open() {

		SLDataBase = SLOHhelper.getWritableDatabase();
		System.out.println("Overture !");
	}

	/**
	 * Fermeture de la base de donnees
	 */
	public void close() {
		SLDataBase.close();
		System.out.println("Fermeture !");
	}

	/**
	 * Implementation des methodes pour les Joueurs Par ordre d'apparition dans
	 * l interface !
	 */

	/**
	 * @param player
	 * @return createId
	 * @throws DatabaseException
	 *             Ajouter un joueur dans la base de donnees en mettant son nom,
	 *             son prenom ainsi que sa nationalite.
	 */
	/* Ajouter joueur à la base de donné */
	protected int Save(Player player) throws DatabaseException {
		ContentValues contentValues = new ContentValues();
		contentValues.put(VolleyOpenhelper.Player_Columns_NAME,
				player.getName());
		contentValues.put(VolleyOpenhelper.Player_Columns_FIRSTNAME,
				player.getFirstname());
		contentValues.put(VolleyOpenhelper.Player_Columns_NATIONALITY,
				player.getNationality());

		long createId = SLDataBase.insert(VolleyOpenhelper.PLAYER_TABLE_NAME,
				null, contentValues);
		if (createId == -1) {
			throw new DatabaseException("Erreur lors de l'ajout du joueur");
		} else {
			System.out.println("Nouveau Joueur ajouté avec l'id : " + createId);
			player.setId((int) createId);
		}
		return (int) createId;
	}

	/**
	 * @param player
	 * @throws DatabaseException
	 *             Modification d'un joueur. On pourra modifier son nom, son
	 *             prenom ainsi que sa nationalite.
	 */
	protected void Update(Player player) throws DatabaseException {
		ContentValues contentValues = new ContentValues();
		contentValues.put(VolleyOpenhelper.Player_Columns_NAME,
				player.getName());
		contentValues.put(VolleyOpenhelper.Player_Columns_FIRSTNAME,
				player.getFirstname());
		contentValues.put(VolleyOpenhelper.Player_Columns_NATIONALITY,
				player.getNationality());

		int result = SLDataBase.update(VolleyOpenhelper.PLAYER_TABLE_NAME,
				contentValues, VolleyOpenhelper.Player_Columns_ID + "="
						+ player.getId(), null);
		if (result == 0) {
			throw new DatabaseException("Le joueur à modifier n'éxite pas");
		} else {
			System.out.println("Le joueur " + player.getId()
					+ " à été mis à jour");
		}
	}

	/**
	 * @param j
	 * @return boolean
	 * @throws DatabaseException
	 *             Methode de recherche d un joueur. En effet celle ci va nous
	 *             renvoyer vrai si un joueur est dans la base de donnees sinon
	 *             elle nous renverra faux.
	 */
	protected boolean ExistPlayer(Player j) throws DatabaseException {
		Cursor cursor = SLDataBase.query(VolleyOpenhelper.PLAYER_TABLE_NAME,
				new String[] { VolleyOpenhelper.Player_Columns_ID },
				VolleyOpenhelper.Player_Columns_ID + "=" + j.getId(), null,
				null, null, null);
		if (cursor != null && cursor.getCount() > 0) {
			cursor.close();
			return true;
		} else {
			cursor.close();
			return false;
		}
	}

	/**
	 * @param player
	 * @throws DatabaseException
	 *             Methode de commit. Celle ci mettra a jour un joueur si celui
	 *             ci existe prealablement, sinon elle l ajoutera dans la base
	 *             de donnees
	 */
	@Override
	public void commit(Player player) throws DatabaseException {
		if (ExistPlayer(player)) {
			Update(player);
		} else {
			Save(player);
		}

	}

	/**
	 * @param player
	 * @throws DatabaseException
	 *             Permet de supprimer un joueur de la base de donnees. Pour
	 *             faire cela, on utilisera son id.
	 */
	@Override
	public void delete(Player player) throws DatabaseException {
		int result = SLDataBase
				.delete(VolleyOpenhelper.PLAYER_TABLE_NAME,
						VolleyOpenhelper.Player_Columns_ID + "="
								+ player.getId(), null);
		if (result != 0) {
			System.out
			.println("Suppression du joueur numero " + player.getId());
			dissociation(player);
		} else {
			throw new DatabaseException("Le joueur a supprimer n'existe pas !");
		}

	}

	/**
	 * @throws DatabaseException
	 * @return listPlayer Renvoie une liste de joueurs qui n appartiennent a
	 *         aucune equipe.
	 */
	@Override
	public ArrayList<Player> getAllPlayerWithoutTeam() throws DatabaseException {

		String req = "(select " + VolleyOpenhelper.Player_Columns_ID + " from "
				+ VolleyOpenhelper.ASSOCIATION_TABLE_NAME + ")";

		Cursor cursor = SLDataBase.query(VolleyOpenhelper.PLAYER_TABLE_NAME,
				new String[] { VolleyOpenhelper.Player_Columns_ID },
				VolleyOpenhelper.Player_Columns_ID + " NOT IN " + req, null,
				null, null, null);

		ArrayList<Player> listPlayer = new ArrayList<Player>();
		if (cursor != null && cursor.getCount() > 0) {
			if (cursor.moveToFirst()) {
				while (cursor.isAfterLast() == false) {
					listPlayer.add(getPlayerById(cursor.getInt(0)));
					cursor.moveToNext();
				}
			}
		} else {
			cursor.close();
			throw new DatabaseException(
					"Tous les joueurs sont dans au moins une equipe");
		}
		cursor.close();
		return listPlayer;
	}

	/**
	 * @param id
	 * @throws DatabaseException
	 * @return j Retourne un joueur identifie grace a son id.
	 */
	@Override
	public Player getPlayerById(int id) throws DatabaseException {
		Cursor cursor = SLDataBase.query(VolleyOpenhelper.PLAYER_TABLE_NAME,
				new String[] { VolleyOpenhelper.Player_Columns_ID,
				VolleyOpenhelper.Player_Columns_NAME,
				VolleyOpenhelper.Player_Columns_FIRSTNAME,
				VolleyOpenhelper.Player_Columns_NATIONALITY },
				VolleyOpenhelper.Player_Columns_ID + "=" + id, null, null,
				null, null);

		if (cursor != null && cursor.getCount() > 0) {
			cursor.moveToFirst();
		} else {
			cursor.close();
			throw new DatabaseException("Aucun joueur n'a cette ID");
		}

		Player j = new Player(Integer.parseInt(cursor.getString(0)),
				cursor.getString(1), cursor.getString(2), cursor.getString(3));
		cursor.close();
		return j;
	}

	/**
	 * @throws DatabaseException
	 * @return listPlayer Retourne la liste de tous les joueurs presents dans la
	 *         base de donnees.
	 */
	@Override
	public ArrayList<Player> getAllPlayer() throws DatabaseException {
		Cursor cursor = SLDataBase.query(VolleyOpenhelper.PLAYER_TABLE_NAME,
				new String[] { VolleyOpenhelper.Player_Columns_ID }, null,
				null, null, null, null);
		ArrayList<Player> listPlayer = new ArrayList<Player>();
		if (cursor != null && cursor.getCount() > 0) {
			if (cursor.moveToFirst()) {
				while (cursor.isAfterLast() == false) {
					listPlayer.add(getPlayerById(cursor.getInt(0)));
					cursor.moveToNext();
				}
			}
		} else {
			cursor.close();
			throw new DatabaseException(
					"Aucun joueur n'est dans la base de donnee");
		}
		cursor.close();
		System.out.println("Il y a : " + cursor.getCount() + " joueurs");
		return listPlayer;
	}

	/**
	 * @param order
	 * @throws DatabaseException
	 * @return cursor Retourne un curseur sur tous les joueurs ordonnes soit par
	 *         leurs noms, soit par leurs prenoms, soit par leurs nationalites.
	 */
	@Override
	public Cursor getAllCursorPlayer(String order) throws DatabaseException {
		if (order != VolleyOpenhelper.Player_Columns_NAME
				&& order != VolleyOpenhelper.Player_Columns_FIRSTNAME
				&& order != VolleyOpenhelper.Player_Columns_NATIONALITY) {
			order = null;
		}
		Cursor cursor = SLDataBase.query(VolleyOpenhelper.PLAYER_TABLE_NAME,
				new String[] { VolleyOpenhelper.Player_Columns_ID + " as _id",
				VolleyOpenhelper.Player_Columns_NAME,
				VolleyOpenhelper.Player_Columns_FIRSTNAME,
				VolleyOpenhelper.Player_Columns_NATIONALITY }, null,
				null, null, null, order);
		return cursor;
	}

	/**
	 * Implementation des methodes Pour les Equipes
	 */

	/**
	 * @param team
	 * @return createId
	 * @throws DatabaseException
	 *             Ajouter une equipe dans la base de donnees en mettant son nom
	 *             et son pays.
	 */
	public int save(Team team) throws DatabaseException {
		ContentValues contentValues = new ContentValues();
		contentValues.put(VolleyOpenhelper.Team_Columns_NAME, team.getName());
		contentValues.put(VolleyOpenhelper.Team_Columns_COUNTRY,
				team.getCountry());

		long createId = SLDataBase.insert(VolleyOpenhelper.TEAM_TABLE_NAME,
				null, contentValues);
		if (createId != -1) {
			System.out.println("Nouvelle Equipe ajoutée avec l'id : "
					+ createId);
			team.setId((int) createId);
		} else {
			throw new DatabaseException("Impossible d'ajouter cette équipe");
		}
		return (int) createId;
	}

	/**
	 * @param team
	 * @throws DatabaseException
	 *             Modification d une equipe. On pourra modifier son nom et son
	 *             pays.
	 */
	public void update(Team team) throws DatabaseException {
		ContentValues contentValues = new ContentValues();
		contentValues.put(VolleyOpenhelper.Team_Columns_NAME, team.getName());
		contentValues.put(VolleyOpenhelper.Team_Columns_COUNTRY,
				team.getCountry());

		int result = SLDataBase.update(VolleyOpenhelper.TEAM_TABLE_NAME,
				contentValues,
				VolleyOpenhelper.Team_Columns_ID + "=" + team.getId(), null);
		if (result == 0) {
			throw new DatabaseException("L'equipe a mettre a jour n'existe pas");
		} else {
			System.out.println("L'equipe " + team.getId()
					+ " a ete mise a jour");
		}

	}

	/**
	 * @param e
	 * @return boolean
	 * @throws DatabaseException
	 *             Methode de recherche d une equipe. En effet celle ci va nous
	 *             renvoyer vrai si une equipe est dans la base de donnees sinon
	 *             elle nous renverra faux.
	 */
	public boolean existTeam(Team e) throws DatabaseException {
		Cursor cursor = SLDataBase.query(VolleyOpenhelper.TEAM_TABLE_NAME,
				new String[] { VolleyOpenhelper.Team_Columns_ID },
				VolleyOpenhelper.Team_Columns_ID + "=" + e.getId(), null, null,
				null, null);
		if (cursor != null && cursor.getCount() > 0) {
			cursor.close();
			return true;
		} else {
			cursor.close();
			return false;
		}
	}

	/**
	 * @param team
	 * @throws DatabaseException
	 *             Methode de commit. Celle ci mettra a jour une equipe si celle
	 *             ci existe prealablement, sinon elle l ajoutera dans la base
	 *             de donnees
	 */
	@Override
	public void commit(Team team) throws DatabaseException {
		if (existTeam(team)) {
			System.out.println("On fait une mise a jour");
			update(team);
			System.out.println("Fin de la mise a jour");
		} else {
			save(team);
		}
	}

	/**
	 * @param team
	 * @throws DatabaseException
	 *             Permet de supprimer une equipe de la base de donnees. Pour
	 *             faire cela, on utilisera son id.
	 */
	@Override
	public void delete(Team team) throws DatabaseException {
		int id = team.getId();
		int result = SLDataBase.delete(VolleyOpenhelper.TEAM_TABLE_NAME,
				VolleyOpenhelper.Team_Columns_ID + "=" + id, null);
		if (result != 0) {
			System.out.println("Suppression de l'equipe numero " + id);
			dissociation(team);
		} else {
			throw new DatabaseException("L'equipe a supprimer n'existe pas");
		}
	}

	/**
	 * @param id
	 * @throws DatabaseException
	 * @return e Retourne une equipe identifie grace a son id.
	 */
	@Override
	public Team getTeamById(int id) throws DatabaseException {
		Cursor cursor = SLDataBase.query(VolleyOpenhelper.TEAM_TABLE_NAME,
				new String[] { VolleyOpenhelper.Team_Columns_ID,
				VolleyOpenhelper.Team_Columns_NAME,
				VolleyOpenhelper.Team_Columns_COUNTRY },
				VolleyOpenhelper.Team_Columns_ID + "=" + id, null, null, null,
				null);
		if (cursor != null && cursor.getCount() > 0) {
			cursor.moveToFirst();
		} else {
			cursor.close();
			throw new DatabaseException("Aucune equipe n'a cette ID");
		}

		Team e = new Team(Integer.parseInt(cursor.getString(0)),
				cursor.getString(1), cursor.getString(2));
		cursor.close();
		return e;
	}

	/**
	 * @throws DatabaseException
	 * @return listTeam Retourne la liste de toutes les equipes presentes dans
	 *         la base de donnees.
	 */
	@Override
	public ArrayList<Team> getAllTeam() throws DatabaseException {
		Cursor cursor = SLDataBase.query(VolleyOpenhelper.TEAM_TABLE_NAME,
				new String[] { VolleyOpenhelper.Team_Columns_ID }, null, null,
				null, null, null);
		ArrayList<Team> listTeam = new ArrayList<Team>();
		if (cursor != null && cursor.getCount() > 0) {
			cursor.moveToFirst();
			while (cursor.isAfterLast() == false) {
				listTeam.add(getTeamById(cursor.getInt(0)));
				cursor.moveToNext();
			}
		} else {
			cursor.close();
			throw new DatabaseException("Aucune equipe dans la base de donnees");
		}
		cursor.close();
		System.out.println("Il y a : " + cursor.getCount() + " equipes");
		return listTeam;
	}

	/**
	 * @param order
	 * @throws DatabaseException
	 * @return cursor Retourne un curseur sur toutes les equipes ordonnees soit
	 *         par leurs noms, soit par leurs nationalites.
	 */
	@Override
	public Cursor getAllCursorTeam(String order) throws DatabaseException {
		if (order != VolleyOpenhelper.Team_Columns_NAME
				&& order != VolleyOpenhelper.Team_Columns_COUNTRY) {
			order = null;
		}
		Cursor cursor = SLDataBase.query(VolleyOpenhelper.TEAM_TABLE_NAME,
				new String[] { VolleyOpenhelper.Team_Columns_ID + " as _id",
				VolleyOpenhelper.Team_Columns_NAME,
				VolleyOpenhelper.Team_Columns_COUNTRY }, null, null,
				null, null, order);
		return cursor;
	}

	/**
	 * Implementation des methodes Pour l'Association Equipe/Joueur
	 */
	/**
	 * @param list
	 * @param player
	 * @return boolean Permet de savoir si un joueur est dans la liste ou non.
	 */
	public static boolean in_array(ArrayList<Player> list, Player player) {
		for (int i = 0; i < list.size(); i++) {
			if (list.get(i).getId() == (player.getId())) {
				return true;
			}
		}
		return false;
	}

	/**
	 * @param player
	 * @param team
	 * @throws DatabaseException
	 *             Permet d'ajouter un joueur dans une equipe.
	 */
	@Override
	public void associate(Player player, Team team) throws DatabaseException {

		ContentValues contentValues = new ContentValues();
		contentValues.put(VolleyOpenhelper.Player_Columns_ID, player.getId());
		contentValues.put(VolleyOpenhelper.Team_Columns_ID, team.getId());
		ArrayList<Player> ARplayer = new ArrayList<Player>();
		try {
			ARplayer = getAllPlayerInTeam(team);
		} catch (Exception e) {
		} finally {
			if (in_array(ARplayer, player)) {
				System.out.println("Le joueur " + player.getId()
						+ " est deja dans l'equipe " + team.getId());
			} else {
				long ret = SLDataBase.insert(
						VolleyOpenhelper.ASSOCIATION_TABLE_NAME, null,
						contentValues);
				if (ret != -1) {
					System.out.println("Le joueur : " + player.getId()
							+ " a ete ajoute a l'equipe " + team.getId());
				} else {
					throw new DatabaseException(
							"Impossible d'ajouter l'association");
				}
			}
		}

	}

	/**
	 * @param player
	 * @param team
	 *            Permet de supprimer un joueur d'une equipe specifique.
	 */
	@Override
	public void dissociate(Player player, Team team) throws DatabaseException {
		int idTeam = team.getId();
		int idPlayer = player.getId();
		int result = SLDataBase
				.delete(VolleyOpenhelper.ASSOCIATION_TABLE_NAME,
						VolleyOpenhelper.Player_Columns_ID + "=" + idPlayer
						+ " AND " + VolleyOpenhelper.Team_Columns_ID
						+ "=" + idTeam, null);
		if (result != 0) {
			System.out.println("Le joueur " + idPlayer
					+ " ne fait plus parti de l'equipe " + idTeam);
		} else {
			throw new DatabaseException("Impossible de dissocier l'association");
		}

	}

	/**
	 * @param player
	 *            Permet de supprimer un joueur de toutes les equipes auxquelles
	 *            il appartient.
	 */
	@Override
	public void dissociation(Player player) throws DatabaseException {
		int idPlayer = player.getId();
		int result = SLDataBase.delete(VolleyOpenhelper.ASSOCIATION_TABLE_NAME,
				VolleyOpenhelper.Player_Columns_ID + "=" + idPlayer, null);
		if (result != 0) {
			System.out.println("Le joueur " + idPlayer
					+ "a ete dissocie de toutes les equipes");
		} else {
			throw new DatabaseException(
					"Impossible de supprimer le joueur d'une association\n"
							+ "Il se peut que ce message aparaisse si le joueur que vous supprimez n'etait associe a aucune equipe");
		}

	}

	/**
	 * @param team
	 *            Permet de supprimer une equipe a laquelle les joueurs etaient
	 *            associes.
	 */
	@Override
	public void dissociation(Team team) throws DatabaseException {
		int idTeam = team.getId();
		int result = SLDataBase.delete(VolleyOpenhelper.ASSOCIATION_TABLE_NAME,
				VolleyOpenhelper.Team_Columns_ID + "=" + idTeam, null);
		if (result != 0) {
			System.out.println("Plus aucun joueur n'est associe a l'equipe : "
					+ idTeam);
		} else {
			throw new DatabaseException(
					"Impossible de supprimer l'equipe d'une association\n"
							+ "Il se peut que ce message aparaisse si l'equipe que vous supprimez n'etait associee a aucun joueur");
		}
	}

	/**
	 * @param e
	 * @return listPlayer Retourne une liste de joueurs dans une equipe
	 *         specifique.
	 */
	@Override
	public ArrayList<Player> getAllPlayerInTeam(Team e)
			throws DatabaseException {
		
		int idTeam = e.getId();
		String from = VolleyOpenhelper.ASSOCIATION_TABLE_NAME;
		String[] select = new String[] { VolleyOpenhelper.Player_Columns_ID };
		String where = VolleyOpenhelper.Team_Columns_ID + "=" + idTeam;
		// Select => Joueur_Columns_ID
		// From => ASSOCIATION_TABLE_NAME
		// Where => Equipe_Columns_ID = IdEquipe

		Cursor cursor = SLDataBase.query(from, select, where, null, null, null,
				null);
		ArrayList<Player> listPlayer = new ArrayList<Player>();
		if (cursor != null && cursor.getCount() > 0) {
			cursor.moveToFirst();
			while (cursor.isAfterLast() == false) {
				System.out.println(cursor.getInt(0));
				listPlayer.add(getPlayerById(cursor.getInt(0)));
				cursor.moveToNext();
			}
			cursor.close();
		} else {
			cursor.close();
			throw new DatabaseException("Cette equipe n'a aucun joueur");
		}
		return listPlayer;
	}

	/**
	 * @param e
	 * @return cursor Retourne un curseur sur tous les joueurs dans une equipe.
	 */
	@Override
	public Cursor getAllCursorPlayerInTeam(Team e) throws DatabaseException {
		int idTeam = e.getId();
		String from = VolleyOpenhelper.PLAYER_TABLE_NAME + " JOIN "
				+ VolleyOpenhelper.ASSOCIATION_TABLE_NAME + " ON "
				+ VolleyOpenhelper.PLAYER_TABLE_NAME + "."
				+ VolleyOpenhelper.Player_Columns_ID + "="
				+ VolleyOpenhelper.ASSOCIATION_TABLE_NAME + "."
				+ VolleyOpenhelper.Player_Columns_ID;
		String[] select = new String[] {
				VolleyOpenhelper.PLAYER_TABLE_NAME + "."
						+ VolleyOpenhelper.Player_Columns_ID + " as _id",
						VolleyOpenhelper.PLAYER_TABLE_NAME + "."
								+ VolleyOpenhelper.Player_Columns_NAME,
								VolleyOpenhelper.PLAYER_TABLE_NAME + "."
										+ VolleyOpenhelper.Player_Columns_FIRSTNAME,
										VolleyOpenhelper.PLAYER_TABLE_NAME + "."
												+ VolleyOpenhelper.Player_Columns_NATIONALITY };
		String where = VolleyOpenhelper.ASSOCIATION_TABLE_NAME + "."
				+ VolleyOpenhelper.Team_Columns_ID + "=" + idTeam;

		Cursor cursor = SLDataBase.query(from, select, where, null, null, null,
				null);
		return cursor;
	}

	/**
	 * @param e
	 * @return cursor Retourne un curseur sur tous les joueurs qui ne sont pas
	 *         dans une equipe.
	 */
	@Override
	public Cursor getAllCursorPlayerNotInTeam(Team e) throws DatabaseException {
		int idTeam = e.getId();

		String req = "(SELECT " + VolleyOpenhelper.PLAYER_TABLE_NAME + "."
				+ VolleyOpenhelper.Player_Columns_ID + " FROM "
				+ VolleyOpenhelper.PLAYER_TABLE_NAME + " JOIN "
				+ VolleyOpenhelper.ASSOCIATION_TABLE_NAME + " ON "
				+ VolleyOpenhelper.PLAYER_TABLE_NAME + "."
				+ VolleyOpenhelper.Player_Columns_ID + "="
				+ VolleyOpenhelper.ASSOCIATION_TABLE_NAME + "."
				+ VolleyOpenhelper.Player_Columns_ID + " WHERE "
				+ VolleyOpenhelper.ASSOCIATION_TABLE_NAME + "."
				+ VolleyOpenhelper.Team_Columns_ID + "=" + idTeam + ")";

		String from = VolleyOpenhelper.PLAYER_TABLE_NAME;
		String[] select = new String[] {
				VolleyOpenhelper.Player_Columns_ID + " as _id",
				VolleyOpenhelper.Player_Columns_NAME,
				VolleyOpenhelper.Player_Columns_FIRSTNAME,
				VolleyOpenhelper.Player_Columns_NATIONALITY };
		String where = VolleyOpenhelper.Player_Columns_ID + " NOT IN " + req;

		Cursor cursor = SLDataBase.query(from, select, where, null, null, null,
				null);
		return cursor;
	}

	/**
	 * Methodes gestion des stats.
	 */

	/**
	 * @param idAction
	 * @param idTeam
	 * @param idPlayer
	 * @param idMatch
	 * @return createId
	 * @throws DatabaseException
	 *             Methode de commit. Celle ci ajoutera une action avec le
	 *             joueur, son equipe et le match dans lequel il a jouer dans la
	 *             base de donnees
	 */
	@Override
	public long commit(int idAction, int idTeam, int idPlayer, int idMatch, int idTargetPlayer, int mark)
			throws DatabaseException {
		ContentValues contentValues = new ContentValues();
		contentValues.put(VolleyOpenhelper.Player_Columns_ID, idPlayer);
		contentValues.put(VolleyOpenhelper.Team_Columns_ID, idTeam);
		contentValues.put(VolleyOpenhelper.Statistic_Columns_IDTARGERPLAYER, idTargetPlayer);
		contentValues.put(VolleyOpenhelper.Statistic_Columns_MARK, mark);
		contentValues
		.put(VolleyOpenhelper.Statistic_Columns_IDACTION, idAction);
		contentValues.put(VolleyOpenhelper.Statistic_Columns_IDMATCH, idMatch);

		long createId = SLDataBase.insert(
				VolleyOpenhelper.STATISTIC_TABLE_NAME, null, contentValues);
		if (createId == -1) {
			throw new DatabaseException(
					"Erreur lors de l'ajout du joueur de la stat");
		} else {
			System.out.println("Stat ajouté avec l'id : " + createId);
		}
		return createId;
	}

	/**
	 * @param id
	 * @param idAction
	 * @param idTeam
	 * @param idPlayer
	 * @param idMatch
	 * @return createId
	 * @throws DatabaseException
	 *             Methode de mise a jour. Celle ci mettra a jour une action
	 *             avec le joueur, son equipe et le match dans lequel il a jouer
	 *             dans la base de donnees
	 */
	@Override
	public void update(int id, int idMatch, int idTeam, int idPlayer,
			int idAction) throws DatabaseException {
		ContentValues contentValues = new ContentValues();
		contentValues.put(VolleyOpenhelper.Statistic_Columns_ID, id);
		contentValues.put(VolleyOpenhelper.Player_Columns_ID, idPlayer);
		contentValues.put(VolleyOpenhelper.Team_Columns_ID, idTeam);
		contentValues
		.put(VolleyOpenhelper.Statistic_Columns_IDACTION, idAction);
		contentValues.put(VolleyOpenhelper.Statistic_Columns_IDMATCH, idMatch);
		long createId = SLDataBase.update(
				VolleyOpenhelper.STATISTIC_TABLE_NAME, contentValues,
				VolleyOpenhelper.Statistic_Columns_ID + "=" + id, null);
		if (createId == -1) {
			throw new DatabaseException("Erreur lors de la modification");
		} else {
			System.out.println("Modification effectué");
		}
	}

	/**
	 * @param id
	 * @throws DatabaseException
	 *             Methode de suppression. Celle ci supprimera une action dans
	 *             la base de donnees grace a l id
	 */
	@Override
	public void delete(int id) throws DatabaseException {
		int result = SLDataBase.delete(VolleyOpenhelper.STATISTIC_TABLE_NAME,
				VolleyOpenhelper.Statistic_Columns_ID + "=" + id, null);
		if (result != 0) {
			System.out.println("Suppression de la stat " + id);
		} else {
			throw new DatabaseException("La stat à supprimer n'existe pas !");
		}

	}

	/**
	 * @throws DatabaseException
	 *             Methode qui permet de renvoyer l id le plus haut d un match
	 *             passe.
	 */
	@Override
	public int getIdGameHigher() throws DatabaseException {
		Cursor cursor = SLDataBase.query(VolleyOpenhelper.STATISTIC_TABLE_NAME,
				new String[] { "max(" + VolleyOpenhelper.Statistic_Columns_ID
				+ ")" }, null, null, null, null, null);
		if (cursor != null && cursor.getCount() > 0) {
			cursor.moveToFirst();
			return cursor.getInt(0);
		} else {
			cursor.close();
			return 0;
		}
	}

	/**
	 * 
	 * @param cursor
	 * @param idPlayer
	 * @return
	 * @throws DatabaseException
	 */
	public ArrayList < TreeMap<String, Integer> > cursorToTreeMap(Cursor cursor) throws DatabaseException{
		ArrayList < TreeMap<String, Integer> > map = new ArrayList<TreeMap<String,Integer>>();
		if (cursor != null && cursor.getCount() > 0) {
			cursor.moveToFirst();
			int i=0;
			while (cursor.isAfterLast() == false) {
				map.add(new TreeMap<String, Integer>());
				map.get(i).put(VolleyOpenhelper.Player_Columns_ID, cursor.getInt(0));
				map.get(i).put(VolleyOpenhelper.Statistic_Columns_IDACTION, cursor.getInt(1));
				map.get(i).put(VolleyOpenhelper.Statistic_Columns_IDMATCH, cursor.getInt(2));
				map.get(i).put(VolleyOpenhelper.Statistic_Columns_IDTARGERPLAYER, cursor.getInt(3));
				map.get(i).put(VolleyOpenhelper.Statistic_Columns_MARK, cursor.getInt(4));
				map.get(i).put(VolleyOpenhelper.Team_Columns_ID, cursor.getInt(5));
				i++;
				cursor.moveToNext();
			}
		} else {
			cursor.close();
		//	throw new DatabaseException("Rien n'a été trouvé pour ce joueur");
		}
		cursor.close();
		return map;
	}
	
	/**
	 * @param idPlayer
	 * @return TreeMap
	 * @throws Rien n'a été trouvé pour le numero de joueur passé en parametre
	 */
	@Override
	public  ArrayList < TreeMap<String, Integer> > getStatPlayer(int idPlayer)
			throws DatabaseException {
		String[] select = new String[] { 
				VolleyOpenhelper.Player_Columns_ID,
				VolleyOpenhelper.Statistic_Columns_IDACTION,
				VolleyOpenhelper.Statistic_Columns_IDMATCH, 
				VolleyOpenhelper.Statistic_Columns_IDTARGERPLAYER,
				VolleyOpenhelper.Statistic_Columns_MARK,
				VolleyOpenhelper.Team_Columns_ID
		};

		String from = VolleyOpenhelper.STATISTIC_TABLE_NAME;
		
		System.out.println("id player : "+ idPlayer);
		String where = VolleyOpenhelper.Player_Columns_ID + " = " + idPlayer;

		Cursor cursor = SLDataBase.query(from, select, where, null, null, null,
				null);
		return cursorToTreeMap(cursor);
	}


	/**
	 * 
	 */
	@Override
	public  ArrayList < TreeMap<String, Integer> > getStatPlayer(int idPlayer, int idMatch)
			throws DatabaseException {
		
		String[] select = new String[] {
			VolleyOpenhelper.Player_Columns_ID,
			VolleyOpenhelper.Statistic_Columns_IDACTION,
			VolleyOpenhelper.Statistic_Columns_IDMATCH, 
			VolleyOpenhelper.Statistic_Columns_IDTARGERPLAYER,
			VolleyOpenhelper.Statistic_Columns_MARK,
			VolleyOpenhelper.Team_Columns_ID
		};

		String from = VolleyOpenhelper.STATISTIC_TABLE_NAME;

		String where = VolleyOpenhelper.Player_Columns_ID + " = " + idPlayer + 
				" AND " + VolleyOpenhelper.Statistic_Columns_IDMATCH + " = " +idMatch;

		Cursor cursor = SLDataBase.query(from, select, where, null, null, null,
				null);
		
		return cursorToTreeMap(cursor);
	}

	
	/**
	 * 
	 */
	@Override
	public  ArrayList < TreeMap<String, Integer> >  getStatMatch(int idMatch)
			throws DatabaseException {
		
		String[] select = new String[] {
				VolleyOpenhelper.Player_Columns_ID,
				VolleyOpenhelper.Statistic_Columns_IDACTION,
				VolleyOpenhelper.Statistic_Columns_IDMATCH, 
				VolleyOpenhelper.Statistic_Columns_IDTARGERPLAYER,
				VolleyOpenhelper.Statistic_Columns_MARK,
				VolleyOpenhelper.Team_Columns_ID
				
		};

		String from = VolleyOpenhelper.STATISTIC_TABLE_NAME;

		String where = VolleyOpenhelper.Statistic_Columns_IDMATCH + " = " +idMatch;

		Cursor cursor = SLDataBase.query(from, select, where, null, null, null,
				null);
		
		return cursorToTreeMap(cursor);
	}
	
	
	
	
	/**
	 * Reinitialise toute la base de donnees.
	 */
	@Override
	public void reset() {
		SLDataBase.delete(VolleyOpenhelper.ASSOCIATION_TABLE_NAME, null, null);
		SLDataBase.delete(VolleyOpenhelper.TEAM_TABLE_NAME, null, null);
		SLDataBase.delete(VolleyOpenhelper.PLAYER_TABLE_NAME, null, null);

	}

}
